package com.cishu.orancle.utils;

import com.cishu.orancle.common.CustomException;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
public class Tools {
    /**
     * 去除字符串中的特殊字符
     * @param str 原始字符串
     * @return 去除特殊字符后的字符串
     */
    public static String removeSpecialCharacters(String str) {
        if (str == null) {
            return null;
        }
        String specialChars = "[`~!@#$%^&*()_\\-+=<>?:\"{}|,./;'\\[\\]\\\\]";
        return str.replaceAll(specialChars, " ");
    }

    /**
     * 判断一个字符串为空 ("")、null 或者全由空格组成
     * */
    public static boolean strIsBlank(String str) {
        return str==null || str.isEmpty() || str.trim().isEmpty();
    }

    /**
     * 判断一个字符串中是否有空格
     * */
    public static boolean strHasSpace(String str) {
        return str==null || str.contains(" ");
    }

    /**
     * 从标签数组中获取相似度最高的标签
     * */
    public static String compareLabels(List<Map<String, String>> array, String strInput) {
        if (strInput == null) {
            return null;
        }

        int maxCount = 0;
        String resultValue = "";

        for (Map<String, String> obj : array) {
            String label = obj.get("label");
            String value = obj.get("value");

            // 找到字符串与标签之间的共同字符
            HashSet<Character> commonChars = new HashSet<>();
            for (char c : strInput.toCharArray()) {
                commonChars.add(c);
            }

            HashSet<Character> labelChars = new HashSet<>();
            for (char c : label.toCharArray()) {
                labelChars.add(c);
            }

            commonChars.retainAll(labelChars);
            int commonCount = commonChars.size();

            if (commonCount > maxCount) {
                maxCount = commonCount;
                resultValue = value;
                if (maxCount == label.length()) {
                    break;
                }
            }
        }

        return resultValue;
    }

    /**
     * 根据List<Map<String, String>>的value值获取对应的label
     * */

    public static String getLabelByValue(List<Map<String, String>> getBookFormatMap, String value) {
        // 将 List 转换为 Map 以便快速查找
        Map<String, String> valueToLabelMap = new HashMap<>();
        for (Map<String, String> entry : getBookFormatMap) {
            valueToLabelMap.put(entry.get("value"), entry.get("label"));
        }
        // 根据 value 查找对应的 label
        return valueToLabelMap.get(value);
    }

    /**
     * 日期格式化
     * */

    public static String formatIllegalDate(String date) {
        if(strIsBlank(date)) {
            return "";
        }
        // 定义多种可能的日期格式
        String[] formats = {
                "yyyy-MM", "yyyyMM", "yyyyMMdd",
                "yyyy年M月", "yyyy年MM月",
                "yyyy年MM月dd日", "yyyy-MM-dd",
                "yyyy/MM", "yyyy/MM/dd",
                "yyyy/M", "yyyy/M/d",
                "yyyy/M/d"
        };

        for (String format : formats) {
            try {
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format, Locale.CHINA);
                LocalDate localDate = LocalDate.parse(date, formatter);
                return localDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
            } catch (Exception e) {
                // 忽略解析异常，尝试下一个格式
            }
        }

        // 处理只有年份和月份的情况
        if (date.matches("\\d{4}[-/]\\d{1,2}")) {
            String[] parts = date.split("[-/]");
            return String.format("%s-%02d-01", parts[0], Integer.parseInt(parts[1]));
        }

        // 处理格式如 "202001"
        if (date.matches("\\d{6}")) {
            return String.format("%s-%s-01", date.substring(0, 4), date.substring(4, 6));
        }

        // 处理 "2020年1月" 和 "2020年01月"
        if (date.matches("\\d{4}年\\d{1,2}月")) {
            String[] parts = date.split("年|月");
            return String.format("%s-%02d-01", parts[0], Integer.parseInt(parts[1]));
        }

        throw new CustomException("无法解析日期: " + date);
    }

    // 格式化DCC将换行符替换为p标签等
    public static  String formatDccRichText(String input) {
        if (input == null || input.isEmpty()) {
            return "";
        }
        // 去除前后空白并按照行分割
        String[] lines = input.trim().split("\\r?\\n");

        // 使用 StringBuilder 构建最终格式化文本
        StringBuilder formattedText = new StringBuilder();

        // 遍历每一行并用 <p> 标签包裹
        for (String line : lines) {
            if (!line.trim().isEmpty()) { // 忽略空行
                // 替换每行中的多余空格为 &nbsp;
//                String formattedLine = line.replace("    ", "&nbsp;&nbsp;&nbsp;&nbsp;");
                formattedText.append("<p>").append(line).append("</p>");
            }
        }
        return formattedText.toString();
    }


    private static final ObjectMapper mapper = new ObjectMapper();

    /**
     * 替换 JSON 中的占位符，并返回新的 JSON 对象列表。
     * 支持任意对象类型组成的列表，返回 List<Map<String, Object>>。
     *
     * @param placeholderMap 占位符与替换值映射
     * @return 替换后的 JSON 列表（键值结构）
     * @throws Exception JSON 解析失败时抛出
     */

    public static Map<String, Object> replacePlaceholders(
            Map<String, Object> jsonMap,
            Map<String, Object> placeholderMap) throws Exception {

        ObjectMapper mapper = new ObjectMapper();

        // 1. 原始序列化为字符串
        String jsonString = mapper.writeValueAsString(jsonMap);

        // 2. 遍历每个占位符，替换所有匹配形式（无引号/有引号）
        for (Map.Entry<String, Object> entry : placeholderMap.entrySet()) {
            String rawKey = entry.getKey(); // 如 【#DCC_VALUE=1级类目】
            String quotedKey = "\"" + rawKey + "\""; // JSON 中的键形式

            String rawReplacement = String.valueOf(entry.getValue());
            String quotedReplacement = mapper.writeValueAsString(entry.getValue());

            // 替换所有场景：
            jsonString = jsonString.replace(quotedKey, quotedReplacement); // JSON key 替换
            jsonString = jsonString.replace(rawKey, rawReplacement);       // HTML / 字符串内替换
        }

        // 3. 反序列化回 JSON Map
        return mapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});
    }



    /**
     * 过滤字符串，仅保留汉字、英文字母和数字
     * @param input 输入字符串
     * @return 过滤后的字符串
     */
    public static String filterToChineseEnglishDigits(String input) {
        if (input == null) {
            return "";
        }
        return input.replaceAll("[^\\u4e00-\\u9fa5a-zA-Z0-9]", "");
    }

    /**
     * 截取字符串，确保不超过最大长度
     * @param str 输入字符串
     * @param maxLength 最大长度
     * @return 截取后的字符串
     */
    public static String safeSubstring(String str, int maxLength) {
        if (str == null) return "";
        return str.length() > maxLength ? str.substring(0, maxLength) : str;
    }

}
